package com.killer.linear;

/**
 * 数组集合
 * @param <T>
 */
public class MyArrayList<T> implements MyList<T> {

    /**
     * 集合大小
     */
    private int size=0;

    /**
     * 底层存储数组
     */
    private Object[] arrays;

    public MyArrayList() {
        //初始化容量默认为4
        this.arrays = new Object[4];
    }

    public void add(T t) {
        //判断是否需要扩容
        if (size >= arrays.length) {
            //如果集合大小已经大于或等于数组容量,则需要扩容
            resize();
        }
        arrays[size++]=t;
    }

    /**
     * 数组扩容
     */
    private void resize() {
        int capacity=arrays.length*2;
        Object[] newArrays = new Object[capacity];
        for(int i=0;i<arrays.length;i++) {
            newArrays[i]=arrays[i];
        }
        arrays=newArrays;
    }

    public void set(int index, T t) {
        //判断下表是否越界,这里应该要跟size对比,而不是容量对比,因为数组是要连续存储的
        if (index > size - 1) {
            throw new RuntimeException("数组下标越界了");
        }
        //判断是否需要扩容
        if (size >= arrays.length) {
            resize();
        }
        //数组中的元素从index位置开始到末尾需要一直往后移动
        for(int i=size-1;i>=index;i--) {
            arrays[i+1]=arrays[i];
        }
        arrays[index] = t;
        size++;
    }

    public int size() {
        return size;
    }


    public void traverse() {
        for(int i=0;i<size;i++) {
            System.out.println(arrays[i]);
        }
    }

    public T get(int index) {
        if (index > size - 1) {
            throw new RuntimeException("数组下标越界了");
        }
        return (T)arrays[index];
    }

    public void remove(int index) {
        if (index > size - 1) {
            throw new RuntimeException("数组下标越界了");
        }
        //数组中的元素从后往前移动到被删除的位置
        for(int i=index;i<size-1;i++) {
            arrays[i]=arrays[i+1];
        }
        arrays[size - 1] = null;
        size--;
    }
}
